TSL is even simpler, being a straight SDIO problem:

.begin group
INPUT
prefix	::= var%4I%*
	::= f_args%4I%*

f_args%4I%*	::= struct[fn%4I%*:id;args%4I%*:terms%4I%*]

terms%4I%*	::= seq[prefix]

.end
.begin group

OUTPUT
postfix	::= var%4O%*
	::= f_args%4O%*

f_args%4O%*	::= struct[args%4O%*:terms%4O%*;fn%4O%*:id]

terms%4O%*	::= seq[postfix]
.END
.BEGIN GROUP


TRANSFORMATION
var%4O%* = var%4I%*
fn%4O%* = fn%4I%*
args%4O%* = args%4I%*

.END
.BEGIN GROUP;NOFILL;

PROGRAM FOR TRANSFORMATION

pre_to_post[e;prefix]postfix
 generic(e)
	[var%4I%*] =>e
	[f_args%4I%*(u,v)] => f_args%4O%*(arg_list(v),u)
 end;

arg_list(a:terms%4I%*)terms%4O%*
 on(a;*,pre_to_post;ε,terms%4O%*)


.END



INFIX TO POSTFIX TRANSLATOR WITH USUSAL PRECEDENCE
.BEGIN NOFILL

.BEGIN GROUP

	INPUT

exp	::= exp + term
	::= term

term	::= term * fact
	::= fact

fact	::= var
	::= const
	::= (exp)

.END

.begin group

	ABSTRACT SYNTAX

exp	::= sum
	::= term

term	::= prod
	::= fact

fact	::= var
	::= const
	::= paren

sum	::= struct[add1:exp;add2:term]

prod	::= struct[pr1:term;pr2:fact]

paren	::= struct[exp]
.END

.BEGIN GROUP

	OUTPUT

post	::= var
	::= const
	::= post post *
	::= post post +

.END

.BEGIN GROUP
	ABSTRACT SYNTAX

post	::= var
	::= const
	::= postprod
	::= postsum

postsum	::= struct[ar1:post;ar2:post]
postprod::= struct[ar1:post;ar2:post]

.END

.BEGIN GROUP

	TRANSFORMATION : T

var	=> var
const	=> const
sum	=> postsum
prod	=> postprod

.END

problem for APG: write T such that T(exp) = post

.BEGIN GROUP

	THE PROGRAM

inf_to_post(e:exp)post
 generic(e)
	sum(u,v) => postsum(inf_to_post(u),trans_term(v))
	term     => trans_term(e)
 end

trans_term(u:term)post
 generic(u)
	prod(x,y) => postprod(trans_term(x),trans_fact(y))
	fact      => trans_fact(u)
 end

trans_fact(x:fact)post
 generic(x)
	var => x
	const => x
	paren(u) => inf_to_post(u)
 end

.END
.END